C:/Projekte/RAIS/common/FieldData.cs

Go to the documentation of this file.

using System;
using System.Collections.Generic;
using System.Text;

namespace RAIS.Common.TableManagement
{
        public class FieldData
        {
                //*********************************************************************
                #region Fields
                Field field;
                string value = string.Empty;

                int currentLookupValue = 0;
                Dictionary<string, int> currentVisibleLookupValues = new Dictionary<string,int>();
                string currentLookupText = string.Empty;
                Dictionary<string, string> currentVisibleLookupTexts = new Dictionary<string, string>();

                Dictionary<int, string> lookupValues = new Dictionary<int, string>();
                Dictionary<int, string> selectedMultiLookupValues = new Dictionary<int, string>();
                Dictionary<int, string> newMultiLookupValues = new Dictionary<int, string>();
                Dictionary<string, string> visibleLookupValues = new Dictionary<string,string>();
                Dictionary<string, string> visibleSelectedMultiLookupValues = new Dictionary<string, string>();
                Dictionary<string, string> savedVisibleLookupValues;
                Dictionary<string, string> savedVisibleSelectedMultiLookupValues;
                Dictionary<int, string> multiLookupToDelete = new Dictionary<int, string>();
                Dictionary<int, string> multiLookupToInsert = new Dictionary<int, string>();
                bool isUsedAsParameter = false;
                FieldData lookupParent;
                Dictionary<string, FieldData> lookupChilds = new Dictionary<string, FieldData>();
                string controlName;
                bool raisedPostback = false;
                //bool inParameters = false;
                int nonComplianceMajorCategoryID = 0;
                int nonComplianceCategoryID = 0;
                #endregion
                //*********************************************************************
                #region Properties
                public Field Field
                {
                        get { return this.field; }
                        set { this.field = value; }
                }
                public string Value
                {
                        get { return this.value; }
                        set { this.value = value; }
                }
                public int CurrentLookupValue
                {
                        get { return this.currentLookupValue; }
                        set
                        {
                                this.currentLookupValue = value;
                                this.AddCurrentVisibleLookupValue(this.field.Name, value);
                        }
                }
                public string CurrentVisibleLookupValue
                {
                        get 
                        {
                                string key = this.GetCurrentVisisbleLookupKey();
                                return MakeKey(key, this.currentVisibleLookupValues[key]); 
                        }
                }
                public string CurrentLookupText
                {
                        get { return this.currentLookupText; }
                        set
                        {
                                this.currentLookupText = value;
                                this.AddCurrentVisibleLookupText(this.field.Name, value);
                        }
                }
                public string CurrentVisibleLookupText
                {
                        get
                        {
                                string key = this.GetCurrentVisisbleLookupKey();
                                return this.currentVisibleLookupTexts[key];
                        }
                }
                /* Use this field to store lookup value whict have beed red from DB
                 * for SingleLookup and MultiLookup (available values) fields */
                public Dictionary<int, string> LookupValues
                {
                        get { return this.lookupValues; }
                        set { this.AssignLookupValues(value); }
                }
                /* Use this field to store lookup value whict have beed red from DB
                 * for MultiLookup (selected values) fields */
                public Dictionary<int, string> SelectedMultiLookupValues
                {
                        get { return this.selectedMultiLookupValues; }
                }
                public Dictionary<int, string> NewMultiLookupValues
                {
                        get { return this.newMultiLookupValues; }
                        set { this.newMultiLookupValues = value; }
                }
                public string NewMultiLookupValuesInXml
                {
                        get 
                        {
                                string xmlString = "";
                                bool hasChilds = (this.lookupChilds != null && this.lookupChilds.Count != 0);
                                
                                xmlString = "'<Items>";
                                if (this.newMultiLookupValues != null)
                                        foreach (KeyValuePair<int, string> kvp in this.newMultiLookupValues)
                                                xmlString += string.Format("<Item ID=\"{0}\"/>"
                                                        , ((hasChilds) ? FieldData.MakeKey(this.Field.Name, kvp.Key) : kvp.Key.ToString()));

                                if (hasChilds)
                                {
                                        foreach (KeyValuePair<string, FieldData> kvpFieldData in this.lookupChilds)
                                        {
                                                FieldData childFieldData = kvpFieldData.Value;
                                                foreach (KeyValuePair<int, string> kvp in childFieldData.NewMultiLookupValues)
                                                        xmlString += string.Format("<Item ID=\"{0}\"/>"
                                                                , FieldData.MakeKey(childFieldData.Field.Name, kvp.Key));
                                        }
                                }

                                xmlString += "</Items>'";

                                return xmlString; 
                        }
                }
                public Dictionary<string, string> VisibleLookupValues
                {
                        get { return this.visibleLookupValues; }
                }
                public Dictionary<string, string> VisibleSelectedMultiLookupValues
                {
                        get { return this.visibleSelectedMultiLookupValues; }
                }
                public Dictionary<string, string> SavedVisibleLookupValues
                {
                        get { return this.savedVisibleLookupValues; }
                        set { this.savedVisibleLookupValues = value; }
                }
                public Dictionary<string, string> SavedVisibleSelectedMultiLookupValues
                {
                        get { return this.savedVisibleSelectedMultiLookupValues; }
                        set { this.savedVisibleSelectedMultiLookupValues = value; }
                }
                public Dictionary<int, string> MultiLookupToDelete
                {
                        get { return this.multiLookupToDelete; }
                        set { this.multiLookupToDelete = value; }
                }
                public Dictionary<int, string> MultiLookupToInsert
                {
                        get { return this.multiLookupToInsert; }
                        set { this.multiLookupToInsert = value; }
                }
                public bool IsUsedAsParameter
                {
                        get { return this.isUsedAsParameter; }
                        set { this.isUsedAsParameter = value; }
                }
                public FieldData LookupParent 
                {
                        get { return this.lookupParent; }
                        set { this.lookupParent = value; }
                }
                public Dictionary<string, FieldData> LookupChilds
                {
                        get { return this.lookupChilds; }
                        set { this.lookupChilds = value; }
                }
                public string ControlName
                {
                        get { return controlName; }
                        set { controlName = value; }
                }
                public bool RaisedPostback
                {
                        get { return raisedPostback; }
                        set { raisedPostback = value; }
                }
                public int NonComplianceMajorCategoryID
                {
                        get { return this.nonComplianceMajorCategoryID; }
                        set { this.nonComplianceMajorCategoryID = value; }
                }
                public int NonComplianceCategoryID
                {
                        get { return this.nonComplianceCategoryID; }
                        set { this.nonComplianceCategoryID = value; }
                }
                public bool NonComplianceMultilookup
                {
                        get { return (this.Field.Name == Constants.NON_COMPLIANCE_FIELD_NAME); }
                }
                #endregion
                //*********************************************************************
                #region Constructors
                public FieldData(Field field
                                                , string value
                                                , int currentLookupValue
                                                , string currentLookupText
                                                , Dictionary<int, string> lookupValues
                                                , Dictionary<int, string> selectedMultiLookupValues
                                                , FieldData parentFieldData)
                {
                        this.lookupParent = parentFieldData;
                        if (this.lookupParent != null)
                                this.lookupParent.LookupChilds.Add(field.Name, this);

                        this.field = field;
                        this.value = value;
                        this.CurrentLookupValue = currentLookupValue;
                        this.CurrentLookupText = currentLookupText;
                        this.AssignSelectedMultiLookupValues(selectedMultiLookupValues);
                        
                }
                #endregion
                //*********************************************************************
                #region Public Methods
                public void AssignNewMultiLookupValues(Dictionary<string, string> lookupValues)
                {
                        if (lookupValues != null)
                                foreach (KeyValuePair<string, string> kvp in lookupValues)
                                        this.AddNewMultiLookupValue(kvp.Key, kvp.Value);
                }

                public void AddLookupValue(string fieldName, int id, string value)
                {
                        string key = FieldData.MakeKey(fieldName, id);

                        if (this.lookupValues == null)
                                this.lookupValues = new Dictionary<int, string>();

                        if (this.field.Name == fieldName
                                && !this.lookupValues.ContainsKey(id))
                        {
                                this.lookupValues.Add(id, value);
                        }

                        if (this.visibleLookupValues == null)
                                this.visibleLookupValues = new Dictionary<string, string>();
                        if (!this.visibleLookupValues.ContainsKey(key))
                                this.visibleLookupValues.Add(key, value);

                        if (this.lookupParent != null)
                                this.lookupParent.AddLookupValue(fieldName, id, value);
                }

                public void AddSelectedMultiLookupValue(string fieldName, int id, string value)
                {
                        string key = FieldData.MakeKey(fieldName, id);

                        if (this.selectedMultiLookupValues == null)
                                this.selectedMultiLookupValues = new Dictionary<int, string>();

                        if (this.field.Name == fieldName
                                && !this.selectedMultiLookupValues.ContainsKey(id))
                        {
                                this.selectedMultiLookupValues.Add(id, value);
                        }

                        if (this.visibleSelectedMultiLookupValues == null)
                                this.visibleSelectedMultiLookupValues = new Dictionary<string, string>();
                        if (!this.visibleSelectedMultiLookupValues.ContainsKey(key))
                                this.visibleSelectedMultiLookupValues.Add(key, value);

                        if (this.lookupParent != null)
                                this.lookupParent.AddSelectedMultiLookupValue(fieldName, id, value);
                }

                public void AddNewMultiLookupValue(string key, string value)
                {
                        string fieldName;
                        int id;

                        FieldData.SplitKey(key, out fieldName, out id);

                        if (this.field.Name == fieldName)
                        {
                                if (this.newMultiLookupValues == null)
                                        this.newMultiLookupValues = new Dictionary<int, string>();
                                this.newMultiLookupValues.Add(id, value);
                        }
                        else
                        {
                                if (this.lookupChilds.ContainsKey(fieldName))
                                        this.lookupChilds[fieldName].AddNewMultiLookupValue(key, value);
                        }
                }

                public void AssignCurrentVisibleLookupValueAndText(string key, string text)
                {
                        string fieldName;
                        int id;

                        FieldData.SplitKey(key, out fieldName, out id);

                        if (this.field.Name == fieldName)
                        {
                                this.CurrentLookupValue = id;
                                this.CurrentLookupText = text;
                        }
                        else
                        {
                                this.CurrentLookupValue = 0;
                                this.CurrentLookupText = string.Empty;
                        }

                        foreach(KeyValuePair<string, FieldData> kvp in this.lookupChilds)
                        {
                                FieldData lookupChild = kvp.Value;
                                lookupChild.AssignCurrentVisibleLookupValueAndText(key, text);
                        }
                }

                static public string MakeKey(string fieldName, int id)
                {
                        return "[" + fieldName + "]" + id.ToString();
                }
                #endregion
                //*********************************************************************
                #region Private Methods
                private void AssignLookupValues(Dictionary<int, string> lookupValues)
                {
                        if (this.lookupValues == null)
                                this.lookupValues = new Dictionary<int, string>();
                        else
                        {
                                this.lookupValues.Clear();
                                this.visibleLookupValues.Clear();
                        }

                        if (lookupValues != null)
                                foreach (KeyValuePair<int, string> kvp in lookupValues)
                                        this.AddLookupValue(this.field.Name, kvp.Key, kvp.Value);
                }

                private void AssignSelectedMultiLookupValues(Dictionary<int, string> lookupValues)
                {
                        if (this.selectedMultiLookupValues == null)
                                this.selectedMultiLookupValues = new Dictionary<int, string>();
                        else
                                this.selectedMultiLookupValues.Clear();

                        if (lookupValues != null)
                                foreach (KeyValuePair<int, string> kvp in lookupValues)
                                        this.AddSelectedMultiLookupValue(this.field.Name, kvp.Key, kvp.Value);
                }

                private void AddCurrentVisibleLookupValue(string fieldName, int value)
                {
                        if (this.currentVisibleLookupValues.ContainsKey(fieldName))
                                this.currentVisibleLookupValues[fieldName] = value;
                        else
                                this.currentVisibleLookupValues.Add(fieldName, value);

                        if (this.lookupParent != null)
                                this.lookupParent.AddCurrentVisibleLookupValue(fieldName, value);
                }

                private void AddCurrentVisibleLookupText(string fieldName, string value)
                {
                        if (this.currentVisibleLookupTexts.ContainsKey(fieldName))
                                this.currentVisibleLookupTexts[fieldName] = value;
                        else
                                this.currentVisibleLookupTexts.Add(fieldName, value);

                        if (this.lookupParent != null)
                                this.lookupParent.AddCurrentVisibleLookupText(fieldName, value);
                }

                private string GetCurrentVisisbleLookupKey()
                {
                        string key = string.Empty;
                        foreach (KeyValuePair<string, string> kvp in this.currentVisibleLookupTexts)
                        {
                                if (kvp.Value != string.Empty)
                                {
                                        key = kvp.Key;
                                        break;
                                }
                        }

                        return (key == string.Empty) ? this.Field.Name : key;
                }

                static private void SplitKey(string key, out string fieldName, out int id)
                {
                        int firstPost = key.IndexOf('[') + 1;
                        int lastPost = key.IndexOf(']') - 1;
                        if (lastPost < 0)
                                fieldName = string.Empty;
                        else
                                fieldName = key.Substring(firstPost, lastPost - firstPost + 1);
                        id = int.Parse(key.Substring(lastPost + 2, key.Length - lastPost - 2));
                }
                #endregion
        }
}